BUSINESS PROBLEM:
PREDICTING THE RETAIL CUSTOMER RETENTION POTENTIAL LEVEL AS HIGH/MEDIUM/LOW CUSTOMER SEGMENTATION & PATTERN EXTRACTION
Retail company draws the attention of the customers through captivating continual conversations for not facing attrition(customer churn) or drop outs in the halfway. Primary focus should be on profitability, retention, production volumes, loss of potential revenue, imposing additional costs on assets, most importantly CRM factor.
Retailers create the metric to find out the services that they need without loosing them through analysis the historical data and once they are outdated from the plan, we have to try regain them back.
We have to focus on medium level customers by satisfying their needs because they are accountable, proactive, reactive in terms of demanding. If they are satisfied, can renewal their plans and the continuity with the company
So let's deep dive into the patterns and emphasizing concept further.
PREDICTING THE RETAIL CUSTOMER RETENTION POTENTIAL LEVEL AS HIGH/MEDIUM/LOW CUSTOMER SEGMENTATION & PATTERN EXTRACTION
MACHINE LEARNING PROBLEM:
USE A CLASSIFICATION MODEL TO PREDICT THE LIKELYHOOD OF A LIABILITY CUSTOMER RETENTION POTENTIAL LEVEL AS HIGH/MEDIUM/LOW
USE A CLASSIFICATION MODEL TO PREDICT THE LIKELYHOOD OF A LIABILITY CUSTOMER RETENTION POTENTIAL LEVEL AS HIGH/MEDIUM/LOW
In [4]:
import os
import random
import itertools
import pandas as pd
pd.set_option('display.max_columns', 500)
import numpy as np
import warnings
warnings.filterwarnings("ignore")
import seaborn as sns
sns.set(style="darkgrid")
from IPython import display
import matplotlib.pyplot as plt
import plotly.figure_factory as ff
import plotly.offline as py
import plotly.graph_objs as go
import plotly.express as px
import datetime
import matplotlib.pyplot as plt
import plotly.io as pio
from plotly import tools
from sklearn import metrics
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score,accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
import xgboost as xgb
PROJECT WORKFLOW
In [ ]:
display.Image("./project WorkFlow.png")
Out[ ]:
PREDICTIONS FLOW¶
In [ ]:
display.Image("./Predictions Flow.png")
Out[ ]:
- Classification Report Method
In [5]:
def classifcation_report_train_test(y_train, y_train_pred, y_test, y_test_pred):
print('''
=========================================
CLASSIFICATION REPORT FOR TRAIN DATA
=========================================
''')
print(classification_report(y_train, y_train_pred))
print('''
=========================================
CLASSIFICATION REPORT FOR TEST DATA
=========================================
''')
print(classification_report(y_test, y_test_pred))
- Model Selection Method
In [6]:
def model_selection(classifier, name, X_train, y_train,X_test,y_test):
classifier.fit(X_train, y_train)
pred_train = classifier.predict(X_train)
pred_test = classifier.predict(X_test)
results_dict = {}
results_dict['classifier_name'] = name
results_dict['Train_Accuracy'] = accuracy_score(y_train,pred_train)
results_dict['Valid_Accuracy'] = accuracy_score(y_test,pred_test)
return(results_dict)
- Recall,Precision,Accuracy Method
In [7]:
from sklearn.metrics import recall_score,accuracy_score,precision_score
scores = pd.DataFrame(columns=['Model','Train_Accuracy','Test_Accuracy','Train_Recall_macro','Test_Recall_macro','Train_Precision_macro','Test_Precision_macro'])
def get_metrics(train_actual,train_predicted,test_actual,test_predicted,model_description,dataframe):
train_accuracy = accuracy_score(train_actual,train_predicted)
test_accuracy = accuracy_score(test_actual,test_predicted)
train_recall = recall_score(train_actual,train_predicted,average='macro')
test_recall = recall_score(test_actual,test_predicted,average='macro')
train_precision = recall_score(train_actual,train_predicted,average='macro')
test_precision = recall_score(test_actual,test_predicted,average='macro')
dataframe = dataframe.append(pd.Series([model_description,train_accuracy,test_accuracy,train_recall,
test_recall,train_precision,test_precision],
index=scores.columns ), ignore_index=True)
return(dataframe)
- Confusion Metrix Method
In [8]:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix')
print(cm)
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, format(cm[i, j], fmt),
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
Loading the Data
In [38]:
customer_data = pd.read_excel('./TrainData/Customerdata_Train.xlsx')
email_data = pd.read_excel('./TrainData/Emaildata_Train.xlsx')
train_data = pd.read_excel('./TrainData//Train.xlsx')
transactions_data = pd.read_excel('./TrainData/transactionsdata_Train.xlsx')
In [39]:
c_data = customer_data.copy()
e_data = email_data.copy()
t_data = train_data.copy()
trans_data = transactions_data.copy()
Dummifying the Categorical Variables
In [40]:
e_data = pd.get_dummies(data=e_data, columns=['EmailType', 'MailOpened','MailClicked'])
FEATURE ENGINEERING
- Dropping the CustomerID Column
- Checking the EmailType data
In [41]:
e_data = e_data.groupby('CustomerID').sum()
In [42]:
e_data.head()
Out[42]:
- Checking the EmailType data
In [43]:
email_data[email_data["EmailType"] =='WelcomeEmail']
Out[43]:
- Converting DateOfemail Column to datetime type
In [44]:
email_data["DateOfemail"] =pd.to_datetime(email_data["DateOfemail"])
Aggregating the email_data
- Created welcomeEmailDate & RecentInteraction Date columns from the existing DateOfemail column
In [45]:
email_date = email_data.groupby('CustomerID').agg(welcomeEmailDate=('DateOfemail', np.min), RecentInteraction=('DateOfemail', np.max))
In [46]:
email_date.head()
Out[46]:
- Merging the email data and aggregated email data
In [47]:
email = e_data.merge(email_date, how='inner', on='CustomerID')
email.head()
Out[47]:
Aggregating the Transaction Data
- Created totalOrders & OrderFrequency columns from the existing OrderQuantity column
- Created firstOrder & lastOrder date columns from the existing DateOfOrder column
In [48]:
trans_order = trans_data.groupby('CustomerID').agg(totalOrders=('OrderQuantity', np.sum),OrderFrequency = ('OrderQuantity',np.count_nonzero ))
In [49]:
trans_date = trans_data.groupby('CustomerID').agg(firstOrder=('DateOfOrder', np.min), lastOrder=('DateOfOrder', np.max))
- Merging the transaction data and aggregated transaction data
In [50]:
transactions = trans_order.merge(trans_date, on = 'CustomerID', how= 'inner')
transactions.head()
Out[50]:
- Merging the transaction data and email data
In [51]:
data = email.merge(transactions, on = 'CustomerID' , how= 'inner')
data.head()
Out[51]:
- Merging the Customer data with Combined Transaction,Email data
In [52]:
data = customer_data.merge(data, on = 'CustomerID' , how= 'inner')
data.head()
Out[52]:
- Merging the train data(having labels with coressponding CustomerID) with Combined Transaction,Email data,customer data
In [53]:
final_data = data.merge(train_data, on = 'CustomerID' , how= 'inner')
final_data.head()
Out[53]:
- Created new column numberOfDaysWithBusiness by substracting the RecentInteraction & DateOfRegistration date columns
In [54]:
final_data['numberOfDaysWithBusiness'] = final_data['RecentInteraction']-final_data['DateOfRegistration']
- Created new column makingBusiness by substracting the lastOrder & firstOrder date columns
In [55]:
final_data['makingBusiness'] = pd.to_datetime(final_data['lastOrder'])- pd.to_datetime(final_data['firstOrder'])
In [56]:
final_data['ordergap'] = pd.to_datetime(final_data['lastOrder']).max() - pd.to_datetime(final_data['lastOrder'])
In [57]:
final_data['ordergap'] = final_data['ordergap'].dt.days
final_data['numberOfDaysWithBusiness'] = final_data['numberOfDaysWithBusiness'].dt.days
final_data['makingBusiness'] = final_data['makingBusiness'].dt.days
In [58]:
final_data.head()
Out[58]:
About Data
In [59]:
def red_data(data):
return pd.DataFrame({"Data Type":data.dtypes,"No of Unique Data":data.apply(lambda x: x.nunique(),axis=0),
"Levels":data.apply(lambda x: str(x.unique()),axis = 0),"Null_values":data.isnull().sum(),'null%':(data.isnull().sum()/100),'skewness':data.skew(),'kurtosis':data.kurt()})
red_data(final_data)
Out[59]:
In [60]:
date_viz = final_data.copy()
In [61]:
final_data = final_data[['CustomerID', 'City', 'OnlineCommunication',
'AutomaticRefill', 'DoorstepDelivery', 'PreferredDeliveryDay',
'EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no',
'MailClicked_yes',
'totalOrders', 'OrderFrequency',
'RetentionPotential', 'numberOfDaysWithBusiness', 'makingBusiness','ordergap']]
In [62]:
final_data.head()
Out[62]:
Statistics Of The Data
In [63]:
final_data.describe()
Out[63]:
Data Visualizations
In [ ]:
from string import ascii_letters
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style="white")
corr = final_data.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))
f, ax = plt.subplots(figsize=(11, 9))
cmap = sns.diverging_palette(230, 20, as_cmap=True)
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=1, center=0,
square=True, linewidths=.5, cbar_kws={"shrink": .5})
Out[ ]:
- Email_type_customized -> Mails clicked&opned is slightly correlated. Mails not clicked&opened is highly correlated. When the Emails are Customized, the mails has not been clicked and obviously not opened if they haven't clicked.
- Mail_opened_No -> Mail_clicked_No (high correlation) If the mails are not opened, that means they haven't clicked on it. - Total_Orders -> Order_Frequency (Maximally correlated) Order frequency is a metric that helps to define how often customers purchase from a store in a given period of time. Order Freqency = Total orders / total number of unique customers - Order Freqency -> Making business (Maximally correlated) If order Frequnecy is more, we can make bussiness, coreelated in terms of profitabilty.
- No of Days with bussiness -> Making business (Highly correlated) If no of bussiness days are more, obviously we can make more bussiness by efforts we put in to get profits.
- Online Communication -> Making bussiness & no of days with bussiness. (less correlation) If the communication is done through online, customers tend to buy less so that bussiness impacts. also the bussiness days reduces from usual.
- AutomaticRefill -> Order Frequnecy (less correlation) If restocking of items are less, the order frequency might also get lesser.
- Box Plots to check Outliers in the data
In [ ]:
final_data.plot(kind='box',layout=(2,7),subplots=1,figsize=(20,16))
Out[ ]:
Outliers has been detected excessively in¶
- Customers who clicked&Opened their mails.
- Company's TotalOrders & OrderFreqency.
- Bussiness perspective - no of days and bussiness making,ordergap
- Different Color names mentioned in the list
In [33]:
colors = ['Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r', 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu', 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r', 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'crest', 'crest_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'flare', 'flare_r', 'gist_earth', 'gist_earth_r', 'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r', 'gist_stern', 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot', 'hot_r', 'hsv', 'hsv_r', 'icefire', 'icefire_r', 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma', 'magma_r', 'mako', 'mako_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r', 'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow', 'rainbow_r', 'rocket', 'rocket_r', 'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo', 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'vlag', 'vlag_r', 'winter', 'winter_r']
Checking the Frequency Of Each Categorical Variable
In [ ]:
columns = ['City','OnlineCommunication','AutomaticRefill','DoorstepDelivery','PreferredDeliveryDay','RetentionPotential']
for col in columns:
sns.countplot(x=col, data=final_data,palette=random.choice(colors))
plt.title('Number Of {}'.format(col))
plt.show()
- 'City 4' has the highest predominance compared to other states with almost over 9k customers.
- Customers has approched 'Online communication' and can see the surge for almost 15k.
- 'Automactic Refil' has not been spiked and that is minimal in restocking.
- Customers have not prefered 'Door step delivery'.
- Customers preferetially requested the 'Deliveryday' on Monday and Tuesday. There is a brigding balance between mon & tue. - The further 'Continuity(retention)' progress with the company is quite Low.That means the customers are onetime purchasers.
Comparision Plots
- Comparision Of Each Categorical Variable With Target Column
In [ ]:
#plt.title('Comparision Between the {},{} & Customer {}'.format(x,col,'RetentionPotential'))
columns = ['OnlineCommunication','AutomaticRefill','DoorstepDelivery','PreferredDeliveryDay']
for i in columns:
g = sns.catplot(x="City", hue="RetentionPotential", col=i,
data=final_data, kind="count",
height=4, aspect=.7,palette=random.choice(colors));
g.fig.subplots_adjust(top=0.8)
g.fig.suptitle('Comparision Between the City , {} , Customer RetentionPotential'.format(i))
- Customers who has not conversed through 'online communication' tends to have the lowest Retention in City 4, Medium & Highest Retention in City 2. Customers who has conversed through 'online communication' tends to have the lowest & highest Retention in City 4, Medium retention in City 2
- Automatic Refil & door step delivery No - low&high retention in city 4, medium retention in city 2. Yes - lowest retention in all cities.
- Prefered days for delivery in all the cities are on Monday & Tuesday
In [ ]:
final_data.head()
Out[ ]:
In [ ]:
final_data[final_data['totalOrders'] >50000 ]
Out[ ]:
Line Plots
Here to mention¶
- The problem with plotly library is,when we download this jupyter file and converted to html.the diagrams related to plotly package will not be appear for that case.here, i'm loading the images that already performed on the data.if you want original images simply run the cell you will get those visualizations.
- Total OrderFrequency By Day
In [ ]:
date_viz['firstOrder']= pd.to_datetime(date_viz['firstOrder'])
#df['Ship Date']= pd.to_datetime(df['Ship Date'])
daily_quantity = date_viz.groupby('firstOrder')['OrderFrequency'].count().reset_index()
trace0 = go.Scatter(x=daily_quantity['firstOrder'], y=date_viz['OrderFrequency'], name='nflx')
fig0 = go.Figure([trace0])
fig0.update_layout(
title={
'text': "Total OrderFrequency by Day",
'x':0.5,
'xanchor': 'center'})
fig0.show()
display.Image("./images/total_orderfrequency_vs_day.png")
Out[ ]:
- Order sales has seen more in the year 2010, because in 2008 the recession started and to cover up economically it has taken a plunge in 2010 eventually. Markets set up marginally again in 2012 and then followed by 2014-15
- Total lastOrder By Day
In [ ]:
date_viz['lastOrder']= pd.to_datetime(date_viz['lastOrder'])
#df['Ship Date']= pd.to_datetime(df['Ship Date'])
daily_quantity = date_viz.groupby('lastOrder')['totalOrders'].min().reset_index()
trace0 = go.Scatter(x=daily_quantity['lastOrder'], y=date_viz['totalOrders'], name='nflx')
fig0 = go.Figure([trace0])
fig0.update_layout(
title={
'text': "Total totalOrders by Day",
'x':0.5,
'xanchor': 'center'})
fig0.show()
display.Image("./images/totalorder_vs_day.png")
Out[ ]:
- Total order were more seen in period 2010-11, 2014-15.In rest all years it is fluctuating with inflation and deflation
- TotalOrders By Year,Month,DayOfWeek,Month
In [ ]:
date_viz['year'] = date_viz['RecentInteraction'].dt.year
date_viz['month'] = date_viz['RecentInteraction'].dt.month
date_viz['dow'] = date_viz['RecentInteraction'].dt.dayofweek
date_viz['day'] = date_viz['RecentInteraction'].dt.day
trace0 = go.Scatter(x=date_viz.groupby('year')['totalOrders'].count().index, y=date_viz.groupby('year')['totalOrders'].count().values)
trace1 = go.Scatter(x=date_viz.groupby('month')['totalOrders'].count().index, y=date_viz.groupby('month')['totalOrders'].count().values)
trace2 = go.Scatter(x=date_viz.groupby('dow')['totalOrders'].count().index, y=date_viz.groupby('dow')['totalOrders'].count().values)
trace3 = go.Scatter(x=date_viz.groupby('day')['totalOrders'].count().index, y=date_viz.groupby('day')['totalOrders'].count().values)
fig1 = tools.make_subplots(rows=4, cols=1, subplot_titles=('Total totalOrders by Year', 'Total totalOrders by Month', 'Total totalOrders by Day of Week', 'Total totalOrders by Day of Month'))
fig1.append_trace(trace0, 1,1)
fig1.append_trace(trace1, 2,1)
fig1.append_trace(trace2, 3,1)
fig1.append_trace(trace3, 4,1)
fig1['layout'].update(title='', showlegend=False)
fig1
display.Image("./images/totalorders.png")
Out[ ]:
Annual wise- total orders were witnessing more in the period of 2012 and again falling down in the year 2014.
Monthly wise- in the months from last two quarters which means from August to December, most of the festivals fall under these months and people tend to purchase more and in the month January, new year falls and hence the sales raises.
Week wise- the sales are more in the weekends and it gradually steeps down in the weekdays.
Day wise- the salary credits in the first week of the month, the sales immediately rises up to till the mid of the month and rapidly falls down in end of the month.
Scatter Plots
- TotalOrders By CityWise
In [ ]:
def gen_scatter(region, col):
return go.Scatter(
x=date_viz[date_viz.City==region].groupby('month')[col].count().index,
y=date_viz[date_viz.City==region].groupby('month')[col].count().values,
name = region,
mode='markers'
)
data = [
gen_scatter('CITY1', 'totalOrders'),
gen_scatter('CITY2', 'totalOrders'),
gen_scatter('CITY3', 'totalOrders'),
gen_scatter('CITY4', 'totalOrders')
]
layout = go.Layout(
title={
'text': "Total totalOrders by City",
'x':0.5,
'xanchor': 'center'}, xaxis = dict(title = 'Month')
)
fig4 = go.Figure(data=data, layout=layout)
fig4
display.Image("./images/city_vs_total_orders.png")
Out[ ]:
- Each city contribute each sales rate, which means most of the cities falling under last two quarters and first month of the first quarter.
In [37]:
g = sns.relplot(x="PreferredDeliveryDay", y="totalOrders", hue="RetentionPotential", size="MailOpened_yes",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('PreferredDeliveryDay vs totalOrders',size=24)
Out[37]:
- On wednesday, customer has opened mail but the retention potentiality with company is quite low.
- We have to concentrate more on medium rention customers, thats when we can hold them towards our company. On Thursady, opened the mail and retention potentiality is Medium can push them towards highest Rentention.
- On sunday, customer's rentention is high, but then he opened the mail for quite lesser times.Those are loyal customers to us and we cant loose them.
In [40]:
g = sns.relplot(x="EmailType_CustomizedEmail", y="totalOrders", hue="RetentionPotential", size="MailOpened_yes",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('EmailType_CustomizedEmail vs totalOrders',size=24)
Out[40]:
- Customer who has been sent CustomizedEmail, have opened many times but the total orders he made was very less and thus has low retention
- Customer with medium retention, tend open the mails quite lesser and total order were also minimal.
- In the other context, there we have the person who has lowest retention yet more total orders.
In [41]:
final_data[final_data['EmailType_CustomizedEmail'] >250 ]
Out[41]:
In [46]:
g = sns.relplot(x="EmailType_CustomizedEmail", y="MailClicked_yes", hue="RetentionPotential", size="MailOpened_yes",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('EmailType_CustomizedEmail vs MailClicked_yes',size=24)
Out[46]:
- Thus the majority of the customizied emails have not been opened by many customers.
In [59]:
g = sns.relplot(x="OrderFrequency", y="totalOrders", hue="RetentionPotential", size="EmailType_CustomizedEmail",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('OrderFrequency vs TotalOrders',size=24)
Out[59]:
- Customers who got customized emails having low retention potential have lesser orders
In [60]:
g = sns.relplot(x="MailOpened_yes", y="OrderFrequency", hue="RetentionPotential", size="MailClicked_yes",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('MailOpened_yes vs OrderFrequency',size=24)
Out[60]:
- Customers who opened mails, their orders were quite minimal with low retention potentiality majorly.
In [62]:
g = sns.relplot(x="MailOpened_yes", y="totalOrders", hue="RetentionPotential", size="MailClicked_yes",
sizes=(40, 400), alpha=.5, palette=random.choice(colors),
height=6, data=final_data)
g.fig.subplots_adjust(top=0.9)
g.fig.suptitle('MailOpened_yes vs totalOrders',size=24)
Out[62]:
- Customers who clicked mails, their orders were quite minimal with low retention potentiality majorly.
Stripplot Plots
- Comparision Between the TotalOrders &
- PreferredDeliveryDay :
- OnlineCommunication :
- AutomaticRefill :
- DoorstepDelivery :
In [ ]:
columns = ['PreferredDeliveryDay','OnlineCommunication','AutomaticRefill','DoorstepDelivery']
for cols in columns:
#var_name = "PreferredDeliveryDay"
col_order = np.sort(final_data[cols].unique()).tolist()
plt.figure(figsize=(10,5))
sns.stripplot(x=cols, y='totalOrders', data=final_data, order=col_order,hue = 'RetentionPotential',palette=random.choice(colors))
plt.xlabel(cols, fontsize=12)
plt.ylabel('TotalOrders', fontsize=12)
plt.title("Distribution of TotalOrders variable with "+cols, fontsize=15)
plt.show()
- Total orders are more on Monday & tuesday in weekdays with low & medium Rentention.
- In Online Communication-YES/NO, the total orders have taken place with low & medium Rentention.
- In Automatic refil-YES/NO, the total orders have taken place with low & medium Rentention.
- In Door step delivery, customers preffered their total orders to not to be done door delivery with Lowest and medium retention.
- #### Comparision Between the OrderFrequency &
- PreferredDeliveryDay :
- OnlineCommunication :
- AutomaticRefill :
- DoorstepDelivery :
In [ ]:
columns = ['PreferredDeliveryDay','OnlineCommunication','AutomaticRefill','DoorstepDelivery']
for cols in columns:
#var_name = "PreferredDeliveryDay"
col_order = np.sort(final_data[cols].unique()).tolist()
plt.figure(figsize=(10,5))
sns.stripplot(x=cols, y='OrderFrequency', data=final_data, order=col_order,hue = 'RetentionPotential',palette=random.choice(colors))
plt.xlabel(cols, fontsize=12)
plt.ylabel('OrderFrequency', fontsize=12)
plt.title("Distribution of OrderFrequency variable with "+cols, fontsize=15)
plt.show()
- Order frequency are more on Monday & tuesday in weekdays with low & medium Rentention.
- In Online Communication-YES/NO, the order frequency have taken place with low & medium Rentention.
- In Automatic refil-YES/NO, the order frequency have taken place with low & medium Rentention.
- In Door step delivery, customers preffered their order frequency to not to be done door delivery with Lowest and medium retention.
Preparing For ModelBuilding¶
In [29]:
df = final_data.drop('CustomerID',axis=1).copy()
In [30]:
df.head()
Out[30]:
Spliting the data
In [31]:
from sklearn.model_selection import train_test_split
y = df['RetentionPotential']
X = df.loc[:, df.columns != 'RetentionPotential']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=111,stratify = y)
print(X_train.shape, X_test.shape)
In [63]:
y_train = y_train.map(dict(High=2, Low=0,Medium=1))
y_test = y_test.map(dict(High=2, Low=0,Medium=1))
print(y_train.shape, y_test.shape)
In [64]:
num_cols = ["EmailType_CustomizedEmail", 'MailOpened_no', 'MailOpened_yes','MailClicked_no','MailClicked_yes','totalOrders','OrderFrequency','numberOfDaysWithBusiness','makingBusiness','ordergap']
cat_cols =['City', 'PreferredDeliveryDay']
In [65]:
from sklearn.preprocessing import StandardScaler
scaler= StandardScaler()
X_train[num_cols] = scaler.fit_transform(X_train[num_cols])
X_test[num_cols] = scaler.transform(X_test[num_cols])
In [66]:
X_train = pd.DataFrame(X_train)
X_test= pd.DataFrame(X_test)
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
le = LabelEncoder()
for col in cat_cols:
le.fit(X_train[col])
X_train[col] = le.transform(X_train[col])
X_test[col] = le.transform(X_test[col])
- #### Pipeline to build base models
In [ ]:
models = [{'name': 'logreg','label': 'Logistic Regression',
'classifier': LogisticRegression(random_state=88),
},
{'name': 'knn','label':'K Nearest Neighbors',
'classifier':KNeighborsClassifier(),
},
{'name': 'dsc','label': 'Descision Tree',
'classifier': DecisionTreeClassifier(random_state=88),
},
{'name': 'rf', 'label': 'Random Forest',
'classifier': RandomForestClassifier(random_state=88),
},
{'name': 'svc', 'label': 'SVM',
'classifier': SVC(class_weight='balanced',random_state=88),
},
{'name': 'Boosting', 'label': 'Xgboost',
'classifier': xgb.XGBClassifier(class_weight='balanced',objective='multi:softmax',random_state = 88),
}
]
In [ ]:
results_base = []
for m in models:
print(m['name'])
results_base.append(model_selection(m['classifier'],
m['name'],
X_train,
y_train,X_test,y_test
))
print('completed')
- #### Base Models Results In DataFrame
In [ ]:
results_base_models = pd.DataFrame(results_base).sort_values(by='Valid_Accuracy', ascending = False)
results_base_models
Out[ ]:
Base models tuning¶
Logistic Regression Tunning
In [ ]:
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
grid={"C":np.logspace(-3,3,7), "penalty":["l1","l2"]}# l1 lasso l2 ridge
logreg=LogisticRegression()
logreg_cv=GridSearchCV(logreg,grid,cv=10)
logreg_cv.fit(X_train,y_train)
print("tuned hpyerparameters :(best parameters) ",logreg_cv.best_params_)
print("accuracy :",logreg_cv.best_score_)
In [ ]:
logreg_cv.best_params_
Out[ ]:
In [ ]:
log_predict_train=logreg_cv.best_estimator_.predict(X_train)
log_predict_test=logreg_cv.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, log_predict_train, y_test, log_predict_test)
scores = get_metrics(y_train,log_predict_train,y_test,log_predict_test,'Logistic_GridSearchCV',scores)
Decision tree Tunning
In [ ]:
dt_model = DecisionTreeClassifier(class_weight = 'balanced',random_state=88)
grid = {
"max_depth":np.arange(14)+1,
'criterion':['gini','entropy']
}
grid_cv_dt = GridSearchCV(estimator=dt_model, param_grid=grid, cv=3,verbose=1)
grid_cv_dt.fit(X_train, y_train)
Out[ ]:
In [ ]:
grid_cv_dt.best_estimator_
Out[ ]:
In [ ]:
grid_cv_dt.best_params_
Out[ ]:
In [ ]:
dt_predict_train=grid_cv_dt.best_estimator_.predict(X_train)
dt_predict_test=grid_cv_dt.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, dt_predict_train, y_test, dt_predict_test)
#scores = get_metrics(y_train,dt_predict_train,y_test,dt_predict_test,'DecisionTrees_GridSearchCV',scores)
Saving Model to Pickle file
In [ ]:
import pickle
Pkl_Filename = "Models/DT.pkl"
with open(Pkl_Filename, 'wb') as file:
pickle.dump(grid_cv_dt.best_estimator_, file)
In [ ]:
# with open(Pkl_Filename, 'rb') as file:
# Pickled_LR_Model = pickle.load(file)
For to visualize Sample DecisionTrees I have considerd max_depth 2.
In [ ]:
from sklearn import tree
clf = DecisionTreeClassifier(max_depth = 2)
clf.fit(X_train, y_train)
fig, axes = plt.subplots(nrows = 1,ncols = 1,figsize = (3,3), dpi=300)
tree.plot_tree(clf,
feature_names =['CustomerID', 'City', 'OnlineCommunication', 'AutomaticRefill',
'DoorstepDelivery', 'PreferredDeliveryDay', 'EmailType_CustomizedEmail',
'MailOpened_no', 'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes',
'totalOrders', 'OrderFrequency',
'numberOfDaysWithBusiness', 'makingBusiness', 'ordergap'],
class_names=['Low','Medium','High'],
filled = True,rounded = True);
Confusion Matrix
In [ ]:
cnf_matrix = metrics.confusion_matrix(y_test, dt_predict_test)
np.set_printoptions(precision=2)
class_names = ['Low', 'Medium','High']
plt.figure(figsize=(10,5))
plot_confusion_matrix(cnf_matrix, classes=class_names,
title='Confusion matrix DT')
Support Vector Classifier Tunning
In [ ]:
from sklearn.svm import SVC
svc_grid = SVC(class_weight='balanced')
param_grid = {
'C': [0.001, 0.01, 0.1, 1, 10],
'gamma': [0.001, 0.01, 0.1, 1],
'kernel':['linear', 'rbf']}
svc_cv_grid = GridSearchCV(estimator = svc_grid, param_grid = param_grid, cv = 3,verbose=1)
svc_cv_grid.fit(X_train, y_train)
Out[ ]:
In [ ]:
svc_cv_grid.best_estimator_
Out[ ]:
In [ ]:
#predicting using best_estimator
svc_train_pred = svc_cv_grid.best_estimator_.predict(X_train)
svc_test_pred = svc_cv_grid.best_estimator_.predict(X_test)
In [ ]:
classifcation_report_train_test(y_train, svc_train_pred, y_test, svc_test_pred)
Adding weights to the model to handle imbalance data
In [68]:
def CreateBalancedSampleWeights(y_train, largest_class_weight_coef):
classes = np.unique(y_train, axis = 0)
classes.sort()
class_samples = np.bincount(y_train)
total_samples = class_samples.sum()
n_classes = len(class_samples)
weights = total_samples / (n_classes * class_samples * 1.0)
class_weight_dict = {key : value for (key, value) in zip(classes, weights)}
class_weight_dict[classes[1]] = class_weight_dict[classes[1]] * largest_class_weight_coef
sample_weights = [class_weight_dict[y] for y in y_train]
return sample_weights
Passing Our target variable distribution , to get corresponding weights
In [69]:
import math
weights = {}
def create_class_weight(labels_dict,mu=0.15):
total = np.sum(list(labels_dict.values()))
keys = labels_dict.keys()
class_weight = dict()
for key in keys:
score = math.log(mu*total/float(labels_dict[key]))
class_weight[key] = score if score > 1.0 else 1.0
return class_weight
labels_dict = {0: 0.8054156171284634, 1: 0.03689126784214945, 2: 0.15769311502938707}
weights.update(create_class_weight(labels_dict))
- #### Weights of the each class to handle Imbalance data
In [ ]:
weights
Out[ ]:
RandomForest Hyperparameter tuning
In [ ]:
from sklearn.ensemble import RandomForestClassifier
from sklearn.utils.class_weight import compute_class_weight,compute_sample_weight
rfc=RandomForestClassifier(random_state=42)
param_grid = {
'n_estimators': [50,100,150,200],
'max_features': ['auto', 'sqrt'],
'max_depth' : np.arange(14)+1,
'criterion' :['gini', 'entropy']
}
sample_weights=compute_sample_weight(weights,y_train)
grid_cv_rfc = GridSearchCV(estimator=rfc, param_grid=param_grid, cv= 3,verbose=1,scoring='recall_weighted')
grid_cv_rfc.fit(X_train, y_train,sample_weight=sample_weights)
Out[ ]:
In [ ]:
grid_cv_rfc.best_estimator_
Out[ ]:
In [ ]:
grid_cv_rfc.best_params_
Out[ ]:
In [ ]:
rf_predict_train=grid_cv_rfc.best_estimator_.predict(X_train)
rf_predict_test=grid_cv_rfc.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, rf_predict_train, y_test, rf_predict_test)
scores = get_metrics(y_train,rf_predict_train,y_test,rf_predict_test,'RandomForest_GridSearchCV',scores)
Saving Model to Pickle file
In [ ]:
Pkl_Filename = "Models/rf.pkl"
with open(Pkl_Filename, 'wb') as file:
pickle.dump(grid_cv_rfc.best_estimator_, file)
XGBoost Hyperparameter Tuning
In [ ]:
import xgboost as xgb
random_state = np.random.randint(0, 1000)
parameters = {
'max_depth': np.arange(15)+1,
'learning_rate': [0.01,0.05,0.1],
'n_estimators': [50, 100, 150],
'gamma': [0.1],
'subsample': [0.7],
}
xgb_model = xgb.XGBClassifier(objective='multi:softmax',random_state = random_state)
sample_weights=compute_sample_weight(weights,y_train)
grid_cv_xg = GridSearchCV(xgb_model, param_grid=parameters,scoring='recall_weighted',cv=3, verbose=1)
grid_cv_xg.fit(X_train,y_train,sample_weight=sample_weights)
Out[ ]:
In [ ]:
grid_cv_xg.best_estimator_
Out[ ]:
In [ ]:
grid_cv_xg.best_params_
Out[ ]:
In [ ]:
xg_predict_train=grid_cv_xg.best_estimator_.predict(X_train)
xg_predict_test=grid_cv_xg.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, xg_predict_train, y_test, xg_predict_test)
#scores = get_metrics(y_train,xg_predict_train,y_test,xg_predict_test,'XGBoost_GridSearchCV',scores)
Learning Curves
In [ ]:
from mlxtend.plotting import plot_learning_curves
plot_learning_curves(X_train, y_train, X_test, y_test, grid_cv_xg.best_estimator_)
plt.show()
- From the above graph ,our model has varience problem.So we need to perform some more regularization techniques.
In [ ]:
grid_cv_xg.best_estimator_.feature_importances_
Out[ ]:
In [ ]:
feat_importances = pd.Series(grid_cv_xg.best_estimator_.feature_importances_, index = ['City', 'OnlineCommunication', 'AutomaticRefill',
'DoorstepDelivery', 'PreferredDeliveryDay', 'EmailType_CustomizedEmail',
'MailOpened_no', 'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes',
'totalOrders', 'OrderFrequency',
'numberOfDaysWithBusiness', 'makingBusiness', 'ordergap'])
In [ ]:
feat_importances_ordered = feat_importances.nlargest(n=10)
feat_importances_ordered
Out[ ]:
Feature Importance with XGBoost
In [ ]:
## Plot Importance
%matplotlib inline
feat_importances_ordered.plot(kind='barh')
plt.show()
By Considering the Above BestEstimator ,we're tuning the two more parameters
In [ ]:
### Adding More parameters
param_test2 = {
'reg_alpha':[1e-5, 1e-2, 0.1, 1, 100],
'reg_lambda':[1e-5, 1e-2, 0.1, 1, 100]
}
xgb_model = grid_cv_xg.best_estimator_
sample_weights=compute_sample_weight(weights,y_train)
grid_cv_xg_1 = GridSearchCV(xgb_model, param_grid=param_test2,scoring='recall_weighted',cv=3, verbose=1)
grid_cv_xg_1.fit(X_train,y_train,sample_weight=sample_weights)
Out[ ]:
In [ ]:
grid_cv_xg_1.best_params_
Out[ ]:
In [ ]:
grid_cv_xg_1.best_estimator_
Out[ ]:
In [ ]:
xg_predict_train_1=grid_cv_xg_1.best_estimator_.predict(X_train)
xg_predict_test_1=grid_cv_xg_1.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, xg_predict_train_1, y_test, xg_predict_test_1)
scores = get_metrics(y_train,xg_predict_train_1,y_test,xg_predict_test_1,'XGBoost_GridSearchCV',scores)
Confusion Mtarix
In [ ]:
cnf_matrix = metrics.confusion_matrix(y_test, xg_predict_test_1)
np.set_printoptions(precision=2)
class_names = ['Low', 'Medium','High']
plt.figure(figsize=(10,5))
plot_confusion_matrix(cnf_matrix, classes=class_names,
title='Confusion matrix DT')
In [ ]:
Pkl_Filename = "Models/xg.pkl"
with open(Pkl_Filename, 'wb') as file:
pickle.dump(grid_cv_xg_1.best_estimator_, file)
LightGBM Hyperparamter Tuning
In [ ]:
import lightgbm as lgb
parms = {
'max_depth':np.arange(15)+1,
'n_estimators':[30,50,70,100,150],
'learning_rate':[0.01,0.1,1,10],
'subsample':[0.7]
}
clf = lgb.LGBMClassifier()
CV_lgbm = GridSearchCV(estimator = clf,param_grid = parms,cv=3,verbose=1,scoring='recall_weighted')
CV_lgbm.fit(X_train,y_train,sample_weight=sample_weights)
Out[ ]:
In [ ]:
CV_lgbm.best_params_
Out[ ]:
In [ ]:
CV_lgbm.best_estimator_
Out[ ]:
In [ ]:
lg_predict_train_1=CV_lgbm.best_estimator_.predict(X_train)
lg_predict_test_1=CV_lgbm.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, lg_predict_train_1, y_test, lg_predict_test_1)
#scores = get_metrics(y_train,lg_predict_train_1,y_test,lg_predict_test_1,'LGBM_GridSearchCV',scores)
By Considering the Above BestEstimator ,we're tuning the two more parameters
In [ ]:
params = {
'reg_alpha': [0, 1e-1, 1, 2],
'reg_lambda': [0, 1e-1, 1, 5],
'objective': ['multiclass'],
'num_class':[3]
}
clf_1 = CV_lgbm.best_estimator_
CV_lgbm_1 = GridSearchCV(estimator = clf_1,param_grid = params,cv=3,verbose=1,scoring='recall_weighted')
CV_lgbm_1.fit(X_train,y_train,sample_weight=sample_weights)
Out[ ]:
In [ ]:
CV_lgbm_1.best_estimator_
Out[ ]:
In [ ]:
lg_predict_train_1=CV_lgbm_1.best_estimator_.predict(X_train)
lg_predict_test_1=CV_lgbm_1.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, lg_predict_train_1, y_test, lg_predict_test_1)
#scores = get_metrics(y_train,lg_predict_train_1,y_test,lg_predict_test_1,'LGBM_GridSearchCV',scores)
Stacking the MultipleModels Using GridSearchCV Method
In [ ]:
from mlxtend.classifier import StackingClassifier
clf1 = grid_cv_dt.best_estimator_
clf2 = grid_cv_xg.best_estimator_
clf3 = grid_cv_xg_1.best_estimator_
lgbm = CV_lgbm_1.best_estimator_
sclf = StackingClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lgbm)
params = {'decisiontreeclassifier__max_depth': [8],
'meta_classifier__learning_rate': [0.1],
'meta_classifier__max_depth': [8],
'meta_classifier__n_estimators': [50],
}
grid = GridSearchCV(estimator=sclf,
param_grid=params,
cv=10,
scoring='recall_weighted',verbose=1)
grid.fit(X_train, y_train)
cv_keys = ('mean_test_score', 'std_test_score', 'params')
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
print("%0.3f +/- %0.2f %r"
% (grid.cv_results_[cv_keys[0]][r],
grid.cv_results_[cv_keys[1]][r] / 2.0,
grid.cv_results_[cv_keys[2]][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)
In [ ]:
grid.best_estimator_
Out[ ]:
In [ ]:
grid.best_params_
Out[ ]:
In [ ]:
stack_predict_train_1=grid.best_estimator_.predict(X_train)
stack_predict_test_1=grid.best_estimator_.predict(X_test)
classifcation_report_train_test(y_train, stack_predict_train_1, y_test, stack_predict_test_1)
scores = get_metrics(y_train,stack_predict_train_1,y_test,stack_predict_test_1,'Stacked_GridSearchCV',scores)
Final Models With their Corresponding Accuracy,Precision,Recall
In [ ]:
scores
Out[ ]:
In [70]:
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,Dropout
from tensorflow.keras.utils import to_categorical
nclasses = len(np.unique(y_train))
nfeatures = np.size(X_train, axis=1)
target_labels_keras = to_categorical(y_train)
label = y_test.copy()
label = to_categorical(label)
# keras model
model = Sequential()
model.add(Dense(nfeatures, activation='relu', kernel_initializer='he_normal', input_shape=(nfeatures,)))
model.add(Dense(150, activation='relu', kernel_initializer='he_normal'))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu', kernel_initializer='he_normal'))
model.add(Dropout(0.2))
model.add(Dense(50, activation='relu', kernel_initializer='he_normal'))
model.add(Dropout(0.2))
model.add(Dense(20, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(15, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(nclasses, activation='softmax', kernel_initializer='he_normal'))
# compile model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
#fit model
model.fit(X_train, target_labels_keras, batch_size=24,
shuffle=True,
validation_data=(X_test, label), epochs=30,class_weight=weights)
Out[70]:
In [72]:
y_pred_train = model.predict(X_train)
y_pred_train = np.flip(np.argsort(y_pred_train), axis=1)[:, :5]
y_pred_train = np.argmax(y_pred_train, axis=-1)
y_pred_test = model.predict(X_test)
y_pred_test = np.flip(np.argsort(y_pred_test), axis=1)[:, :5]
y_pred_test = np.argmax(y_pred_test, axis=-1)
In [75]:
cnf_matrix = metrics.confusion_matrix(y_test, y_pred_test)
np.set_printoptions(precision=2)
class_names = ['Low', 'Medium','High']
plt.figure(figsize=(10,5))
plot_confusion_matrix(cnf_matrix, classes=class_names,
title='Confusion matrix DT')
In [77]:
Handling outliers by apply quantile transformation
- Data having the Outliers in the numerical columns.
- If we remove the outliers the data become less sufficient to train the ML model.
- With the help of QTransformation We Handle this Outliers.
In [ ]:
df_trans = final_data.drop('CustomerID',axis=1)
In [ ]:
df_trans.head()
Out[ ]:
Applying QuantileTransformation
- This method transforms the features to follow a uniform or a normal distribution. Therefore, for a given feature, this transformation tends to spread out the most frequent values. It also reduces the impact of (marginal) outliers: this is therefore a robust preprocessing scheme.
In [ ]:
from sklearn.preprocessing import QuantileTransformer
qt = QuantileTransformer(output_distribution='normal')
# from sklearn.preprocessing import PowerTransformer
# pt = PowerTransformer() ## default yeo_jhonson
In [ ]:
df_trans['RetentionPotential'] = df_trans['RetentionPotential'].map(dict(High=2, Low=0,Medium=1))
LabelEncoding
In [ ]:
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
le = LabelEncoder()
cat_cols =['City', 'PreferredDeliveryDay']
for col in cat_cols:
le.fit(df_trans[col])
df_trans[col] = le.fit_transform(df_trans[col])
- Splitting the data
In [ ]:
y_scale = df_trans['RetentionPotential']
X_scale = df_trans.loc[:, df_trans.columns != 'RetentionPotential']
X_train_trans, X_test_trans, y_train_trans, y_test_trans = train_test_split(X_scale, y_scale, test_size=0.20, random_state=111,stratify = y)
print(X_train_trans.shape, X_test_trans.shape)
In [ ]:
num_cols = ["EmailType_CustomizedEmail", 'MailOpened_no', 'MailOpened_yes','MailClicked_no','MailClicked_yes','totalOrders','OrderFrequency','numberOfDaysWithBusiness','makingBusiness','ordergap']
X_train_trans[num_cols] = qt.fit_transform(X_train_trans[num_cols])
X_test_trans[num_cols] = qt.fit_transform(X_test_trans[num_cols])
In [ ]:
X_train_trans.head()
Out[ ]:
- After applying the Quantiletransformation checking the distribution of data
In [ ]:
sns.set(style="whitegrid")
df_explore = X_train_trans[num_cols]
for cat in df_explore:
cat_num = df_explore[cat]
print("Plot for %s: total counts = %d" % (cat.upper(), len(cat_num)))
f, ax = plt.subplots(figsize=(10,5))
plot = sns.distplot(cat_num)
plot.set_xticklabels(plot.get_xticklabels(), rotation=45)
plt.show()
- Checking with BoxPlots If Outliers Exist or Not
In [ ]:
X_train_trans.plot(kind='box',layout=(2,8),subplots=1,figsize=(20,16))
Out[ ]:
- As we observe from the above visualizations has less no of Outliers compare to previoues box plots
- Pipeline to run basic algorithms
In [ ]:
results_base_trans = []
for m in models:
print(m['name'])
results_base_trans.append(model_selection(m['classifier'],
m['name'],
X_train_trans,
y_train_trans,X_test_trans,y_test_trans
))
print('completed')
- Results Of BaseModels
In [ ]:
results_base_models_trans = pd.DataFrame(results_base_trans).sort_values(by='Valid_Accuracy', ascending = False)
results_base_models_trans
Out[ ]:
Hyperparamter tuning LGBM On Transformed Data
In [ ]:
parms = {
'max_depth':np.arange(15)+1,
'n_estimators':[50,100,150,200],
'learning_rate':[0.01,0.1,1,10],
'subsample':[0.7]
}
clf = lgb.LGBMClassifier()
CV_lgbm_trans = GridSearchCV(estimator = clf,param_grid = parms,cv=3,verbose=1,scoring='recall_weighted')
CV_lgbm_trans.fit(X_train_trans,y_train_trans,sample_weight=sample_weights)
Out[ ]:
In [ ]:
CV_lgbm_trans.best_params_
Out[ ]:
In [ ]:
lg_predict_train_trans=CV_lgbm_trans.best_estimator_.predict(X_train_trans)
lg_predict_test_trans=CV_lgbm_trans.best_estimator_.predict(X_test_trans)
classifcation_report_train_test(y_train, lg_predict_train_trans, y_test, lg_predict_test_trans)
scores = get_metrics(y_train,lg_predict_train_trans,y_test,lg_predict_test_trans,'LGBM_GridSearchCV_QTransformation_applied',scores)
Hyperparamter tuning XGBoost On Transformed Data
In [ ]:
parameters = {
'max_depth': np.arange(15)+1,
'learning_rate': [0.01,0.05,0.1],
'n_estimators': [50, 100, 150],
'gamma': [0.1],
'subsample': [0.7],
}
xgb_model = xgb.XGBClassifier(objective='multi:softmax',random_state = random_state)
grid_cv_xg_trans = GridSearchCV(xgb_model, param_grid=parameters,scoring='recall_weighted',cv=3, verbose=1)
grid_cv_xg_trans.fit(X_train_trans,y_train_trans,sample_weight=sample_weights)
Out[ ]:
In [ ]:
grid_cv_xg_trans.best_params_
Out[ ]:
In [ ]:
xg_predict_train_trans=grid_cv_xg_trans.best_estimator_.predict(X_train_trans)
xg_predict_test_trans=grid_cv_xg_trans.best_estimator_.predict(X_test_trans)
classifcation_report_train_test(y_train, xg_predict_train_trans, y_test, xg_predict_test_trans)
#scores = get_metrics(y_train,lg_predict_train_trans,y_test,lg_predict_test_trans,'LGBM_GridSearchCV_QTransformation_applied',scores)
In [ ]:
grid_cv_xg_trans.best_estimator_
Out[ ]:
Trail-2 Hyperparamter tuning XGBoost On Transformed Data
In [ ]:
param_test2 = {
'n_estimators': [130,150,200],
'reg_alpha':[1e-5, 1e-2, 0.1, 1, 100],
'reg_lambda':[1e-5, 1e-2, 0.1, 1, 100]
}
xgb = grid_cv_xg_trans.best_estimator_
grid_cv_xg_trans = GridSearchCV(xgb, param_grid=param_test2,scoring='recall_weighted',cv=3, verbose=1)
grid_cv_xg_trans.fit(X_train_trans,y_train_trans,sample_weight=sample_weights)
Out[ ]:
In [ ]:
xg_predict_train_trans=grid_cv_xg_trans.best_estimator_.predict(X_train_trans)
xg_predict_test_trans=grid_cv_xg_trans.best_estimator_.predict(X_test_trans)
classifcation_report_train_test(y_train, xg_predict_train_trans, y_test, xg_predict_test_trans)
scores = get_metrics(y_train,xg_predict_train_trans,y_test,xg_predict_test_trans,'XGBoost_GridSearchCV_QTransformation_applied',scores)
Final Scores of algorithms
In [ ]:
scores
Out[ ]:
Test Preprocessing
In [ ]:
customer_data_test = pd.read_excel('TestData/Customerdata_Test.xlsx')
email_data_test = pd.read_excel('TestData/Emaildata_Test.xlsx')
train_data_test = pd.read_excel('TestData/Test.xlsx')
transactions_data_test = pd.read_excel('TestData/transactionsdata_Test.xlsx')
In [ ]:
c_data_test = customer_data_test.copy()
e_data_test = email_data_test.copy()
t_data_test = train_data_test.copy()
trans_data_test = transactions_data_test.copy()
In [ ]:
e_data_test = pd.get_dummies(data=e_data_test, columns=['EmailType', 'MailOpened','MailClicked'])
In [ ]:
e_data_test = e_data_test.groupby('CustomerID').sum()
email_data_test["DateOfemail"] =pd.to_datetime(email_data_test["DateOfemail"])
In [ ]:
email_data_test = email_data_test.groupby('CustomerID').agg(welcomeEmailDate=('DateOfemail', np.min), RecentInteraction=('DateOfemail', np.max))
In [ ]:
email_test = e_data_test.merge(email_data_test, how='inner', on='CustomerID')
email_test.head()
Out[ ]:
In [ ]:
trans_order_test = trans_data_test.groupby('CustomerID').agg(totalOrders=('OrderQuantity', np.sum),OrderFrequency = ('OrderQuantity',np.count_nonzero ))
trans_date_test = trans_data_test.groupby('CustomerID').agg(firstOrder=('DateOfOrder', np.min), lastOrder=('DateOfOrder', np.max))
transactions_test = trans_order_test.merge(trans_date_test, on = 'CustomerID', how= 'inner')
transactions_test.head()
Out[ ]:
In [ ]:
data_test = email_test.merge(transactions_test, on = 'CustomerID' , how= 'inner')
data_test.head()
Out[ ]:
In [ ]:
data_test = customer_data_test.merge(data_test, on = 'CustomerID' , how= 'inner')
data_test.head()
Out[ ]:
In [ ]:
final_data_test = data_test.merge(train_data_test, on = 'CustomerID' , how= 'inner')
final_data_test.head()
Out[ ]:
In [ ]:
final_data_test['numberOfDaysWithBusiness'] = final_data_test['RecentInteraction']-final_data_test['DateOfRegistration']
In [ ]:
final_data_test['makingBusiness'] = pd.to_datetime(final_data_test['lastOrder'])- pd.to_datetime(final_data_test['firstOrder'])
final_data_test['ordergap'] = pd.to_datetime(final_data_test['lastOrder']).max() - pd.to_datetime(final_data_test['lastOrder'])
final_data_test['ordergap'] = final_data_test['ordergap'].dt.days
final_data_test['numberOfDaysWithBusiness'] = final_data_test['numberOfDaysWithBusiness'].dt.days
final_data_test['makingBusiness'] = final_data_test['makingBusiness'].dt.days
In [ ]:
final_data_test = final_data_test[['CustomerID', 'City', 'OnlineCommunication',
'AutomaticRefill', 'DoorstepDelivery', 'PreferredDeliveryDay',
'EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no',
'MailClicked_yes',
'totalOrders', 'OrderFrequency',
'numberOfDaysWithBusiness', 'makingBusiness','ordergap']]
In [ ]:
final_data_test.head()
Out[ ]:
In [ ]:
test_id = final_data_test['CustomerID']
In [ ]:
final_data_test.drop('CustomerID',axis=1,inplace=True)
In [ ]:
final_data_test[num_cols] = scaler.transform(final_data_test[num_cols])
In [ ]:
final_data_test['PreferredDeliveryDay'] = le.transform(final_data_test['PreferredDeliveryDay'])
In [ ]:
final_data_test['City'] = le.transform(final_data_test['City'])
In [ ]:
In [ ]:
In [ ]:
test = final_data_test.copy()
In [ ]:
test.head()
Out[ ]:
In [ ]:
pred = grid_cv_dt.best_estimator_.predict(test)
In [ ]:
pred
Out[ ]:
In [ ]:
sub = pd.read_csv('submissions/pycaret_first_submission.csv')
sub
Out[ ]:
In [ ]:
sub.drop('RetentionPotential',axis=1,inplace=True)
In [ ]:
sub['RetentionPotential'] = pred
In [ ]:
sub.RetentionPotential.value_counts()
Out[ ]:
In [ ]:
sub.to_csv('dt_submission.csv',index=False)
Clustering¶
- Necessary packages Loading to perform Clustering
In [64]:
from scipy import stats
from sklearn.preprocessing import StandardScaler,normalize
from sklearn.cluster import KMeans
from sklearn.cluster import MiniBatchKMeans
from sklearn.cluster import AgglomerativeClustering
import scipy.cluster.hierarchy as shc
from sklearn.cluster import DBSCAN
from sklearn.mixture import GaussianMixture
from sklearn.cluster import MeanShift
from sklearn.cluster import estimate_bandwidth
from sklearn import metrics
from sklearn.decomposition import PCA
import warnings
warnings.filterwarnings('ignore')
In [92]:
cluster_data_exp = final_data.drop(['CustomerID'],axis=1).copy()
In [66]:
cluster_data_1 = final_data.drop(['CustomerID'],axis=1).copy()
In [67]:
cluster_data.head()
Out[67]:
In [68]:
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
le = LabelEncoder()
cat_cols = ['City','PreferredDeliveryDay']
for col in cat_cols:
le.fit(cluster_data[col])
cluster_data[col] = le.transform(cluster_data[col])
Selecting Appropriate K Value From the ElbowCurve
In [69]:
scores = []
for k in range(2,10):
km = KMeans(n_clusters=k,random_state=123)
km = km.fit(cluster_data)
scores.append(km.inertia_)
dfk = pd.DataFrame({'Cluster':range(2,10), 'Score':scores})
plt.figure(figsize=(8,5))
plt.plot(dfk['Cluster'], dfk['Score'], marker='o')
plt.xlabel('Number of clusters')
plt.ylabel('Inertia')
plt.show()
- #### From the ElbowCurve we will pick k value as 4 or 5
Calculating SilhouetteScore For Each Cluster
- The silhouette value measures how similar a point is to its own cluster (cohesion) compared to other clusters (separation).
In [70]:
for i in range(4,10):
kmeans_labels=KMeans(n_clusters=i,random_state=123).fit_predict(cluster_data)
print("Silhouette score for {} clusters k-means : {} ".format(i,metrics.silhouette_score(cluster_data,kmeans_labels, metric='euclidean').round(3)))
- Hence, when we evaluate both Elbow technique and Silhouette score, optimal cluster numbers are 5 according to K-Means Algorithm. So I have determined 5 as the k values of the K-means model.
- Fitting K-Means Algorithm with n_clusters = 5
In [71]:
kmeans_labels=KMeans(n_clusters=5,random_state=123).fit_predict(cluster_data)
- Applying PCA
In [72]:
pca = PCA(n_components=3).fit_transform(cluster_data)
fig = plt.figure(figsize=(12, 7), dpi=80, facecolor='w', edgecolor='k')
ax = plt.axes(projection="3d")
ax.scatter3D(pca.T[0],pca.T[1],pca.T[2],c=kmeans_labels,cmap='Spectral')
xLabel = ax.set_xlabel('X')
yLabel = ax.set_ylabel('Y')
zLabel = ax.set_zlabel('Z')
- Calculating How many number of customers belongs to Each Cluster
In [76]:
cluster_data['Clusters']=list(kmeans_labels)
customers=pd.DataFrame(cluster_data['Clusters'].value_counts()).rename(columns={'Clusters':'Number of Customers'})
customers.T
Out[76]:
- From the above dataframe Cluster_0 contain more number of customer
In [77]:
cluster_data.columns
Out[77]:
- For the numerical variables we have taken mean as aggregation function with cluster group as a index
In [78]:
cluster_data.set_index('Clusters')
grouped_num=cluster_data.groupby(by='Clusters').mean().round(1)
grouped_num = grouped_num.loc[:,['EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes', 'totalOrders',
'OrderFrequency', 'numberOfDaysWithBusiness', 'makingBusiness',
'ordergap']]
grouped_num
Out[78]:
- Dummifying the the categorical columns inorder to get the frequency of each column and cluster group set as a index
In [80]:
cluster_data_exp = pd.get_dummies(data=cluster_data_1, columns=['City', 'OnlineCommunication','PreferredDeliveryDay','RetentionPotential'])
In [81]:
cluster_data_exp['Clusters'] = cluster_data['Clusters']
In [82]:
cluster_data_exp.columns
Out[82]:
- Groupby with cluster group & categorical columns
In [84]:
cluster_data_exp.set_index('Clusters')
grouped_cat = cluster_data_exp.groupby('Clusters').agg(RetentionPotential_High = ('RetentionPotential_High',np.count_nonzero ),
RetentionPotential_Low = ('RetentionPotential_Low',np.count_nonzero ),
RetentionPotential_Medium = ('RetentionPotential_Medium',np.count_nonzero ),
City_CITY1 = ('City_CITY1',np.count_nonzero ),
City_CITY2 = ('City_CITY2',np.count_nonzero ),
City_CITY3 = ('City_CITY3',np.count_nonzero ),
City_CITY4 = ('City_CITY4',np.count_nonzero ),
OnlineCommunication_0 = ('OnlineCommunication_0',np.count_nonzero ),
OnlineCommunication_1 = ('OnlineCommunication_1',np.count_nonzero ),
PreferredDeliveryDay_Friday = ('PreferredDeliveryDay_Friday',np.count_nonzero ),
PreferredDeliveryDay_Monday = ('PreferredDeliveryDay_Monday',np.count_nonzero ),
PreferredDeliveryDay_Saturday = ('PreferredDeliveryDay_Saturday',np.count_nonzero ),
PreferredDeliveryDay_Sunday = ('PreferredDeliveryDay_Sunday',np.count_nonzero ),
PreferredDeliveryDay_Thursday = ('PreferredDeliveryDay_Thursday',np.count_nonzero ),
PreferredDeliveryDay_Tuesday = ('PreferredDeliveryDay_Tuesday',np.count_nonzero ),
PreferredDeliveryDay_Wednesday = ('PreferredDeliveryDay_Wednesday',np.count_nonzero ),
)
grouped_cat
Out[84]:
- Merging both categorical & numerical gropby dataframes
In [ ]:
final_cluster = grouped_num.merge(grouped_cat,how='inner',on='Clusters')
final_cluster
Out[ ]:
In [ ]:
len(final_cluster.columns)
Out[ ]:
In [ ]:
features = final_cluster.columns
- Cluster Analysis On Each variable with corresponding cluster group
In [ ]:
plt.figure(figsize=(10,40))
for i,j in enumerate(features):
plt.subplot(13,2,i+1)
sns.barplot(final_cluster.index,final_cluster[j])
plt.title(j,fontdict={'color':'darkblue'})
plt.tight_layout()
plt.show()
Insights On Each variable with corresponding cluster group
- Cluster 4 is witnessing more mean value which means that more customized emails have been sent to them.
- Though the more mails have been sent to Cluster 4, yet they haven't opened mails.
- Cluster 1 has an exponential raise in opening the mails sent.
- Clsuter 4 denied to click on the mails sent and witnessing the surge here and followed by cluster1.
- Cluster 1 is instrested to check and Clicked on mails been sent.
- Total orders are more seen in cluster 4.
- Order Frequency are more seen in cluster 4.
- Number of days with bussiness has been seen more with cluster 4.
- Making bussiness is been done with cluster 4.
- Cluster 0 is spotting more Order gaps in the bussiness.
- **Insight:**
- CLUSTER 4 - received more mails, but haven't opened mails and also denied to click the mails "yet they made more orders" consequently company is having good bussiness with clustwhater 4
- CLSUTER 0 - it is contributing less in all the attributes yet highest in order gap that means, it is not purchasing more.
- **11- 26 graph:**
- Low , high , medium retention potentail is seen unanimously in Cluster 0.
- In all the cities, cluster 0 is showing the high surgence.
- Online communication YES&NO- cluster 0
- Customers who came from Cluster 0, had requested for their preferred delivery day majorly.
**Another Method**
- Splitting original dataframe into 3 categories(classes) i.e High,Medium,Low.
- Then applying cluster analysis on each individual classes.
- The main idea is to get more insights from the invidual data.
In [182]:
high = cluster_data_exp[cluster_data_exp['RetentionPotential']=='High']
low = cluster_data_exp[cluster_data_exp['RetentionPotential']=='Low']
medium = cluster_data_exp[cluster_data_exp['RetentionPotential']=='Medium']
In [183]:
high.drop('RetentionPotential',axis=1,inplace=True)
low.drop('RetentionPotential',axis=1,inplace=True)
medium.drop('RetentionPotential',axis=1,inplace=True)
In [184]:
high_exp = high.copy()
low_exp = low.copy()
medium_exp = medium.copy()
In [185]:
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
cat_cols = ['City','PreferredDeliveryDay']
for col in cat_cols:
high[col] = le.fit_transform(high[col])
low[col] = le.fit_transform(low[col])
medium[col] = le.fit_transform(medium[col])
In [181]:
for i in [high,low,medium]:
scores = []
for k in range(2,10):
km = KMeans(n_clusters=k,random_state=123)
km = km.fit(i)
scores.append(km.inertia_)
dfk = pd.DataFrame()
dfk = pd.DataFrame({'Cluster':range(2,10), 'Score':scores})
plt.figure(figsize=(8,5))
plt.plot(dfk['Cluster'], dfk['Score'], marker='o')
plt.title('ElbowCurve')
plt.xlabel('Number of clusters')
plt.ylabel('Inertia')
plt.show()
**ElbowCurve**
- First Curve For high Retention data
- Second Curve For low Retention data
- Third Curve For medium Retention data
- #### For High Retention Data Calculating k value
In [186]:
for i in range(3,10):
kmeans_labels=KMeans(n_clusters=i,random_state=123).fit_predict(high)
print("Silhouette score for {} clusters k-means : {} ".format(i,metrics.silhouette_score(high,kmeans_labels, metric='euclidean').round(3)))
- Hence, when we evaluate both Elbow technique and Silhouette score, optimal cluster numbers are 3 according to K-Means Algorithm. So I have determined 3 as the k values of the K-means model.-
- #### For low Retention Data Calculating k value
In [187]:
for i in range(3,10):
kmeans_labels=KMeans(n_clusters=i,random_state=123).fit_predict(low)
print("Silhouette score for {} clusters k-means : {} ".format(i,metrics.silhouette_score(low,kmeans_labels, metric='euclidean').round(3)))
- Hence, when we evaluate both Elbow technique and Silhouette score, optimal cluster numbers are 6 according to K-Means Algorithm. So I have determined 6 as the k values of the K-means model.-
- #### For medium Retention Data Calculating k value
In [188]:
for i in range(3,10):
kmeans_labels=KMeans(n_clusters=i,random_state=123).fit_predict(medium)
print("Silhouette score for {} clusters k-means : {} ".format(i,metrics.silhouette_score(medium,kmeans_labels, metric='euclidean').round(3)))
- Hence, when we evaluate both Elbow technique and Silhouette score, optimal cluster numbers are 3 according to K-Means Algorithm. So I have determined 3 as the k values of the K-means model.-
In [189]:
kmeans_labels_high = KMeans(n_clusters=3,random_state=123).fit_predict(high)
kmeans_labels_low = KMeans(n_clusters=6,random_state=123).fit_predict(low)
kmeans_labels_medium = KMeans(n_clusters=3,random_state=123).fit_predict(medium)
In [190]:
kmeans_labels_high
Out[190]:
- Applying PCA and visualizing the clusters on High Retention Data
In [193]:
pca = PCA(n_components=3).fit_transform(high)
fig = plt.figure(figsize=(12, 7), dpi=80, facecolor='w', edgecolor='k')
ax = plt.axes(projection="3d")
ax.scatter3D(pca.T[0],pca.T[1],pca.T[2],c=kmeans_labels_high,cmap='Spectral')
xLabel = ax.set_xlabel('X')
yLabel = ax.set_ylabel('Y')
zLabel = ax.set_zlabel('Z')
- Applying PCA and visualizing the clusters on Low Retention Data
In [194]:
pca = PCA(n_components=3).fit_transform(low)
fig = plt.figure(figsize=(12, 7), dpi=80, facecolor='w', edgecolor='k')
ax = plt.axes(projection="3d")
ax.scatter3D(pca.T[0],pca.T[1],pca.T[2],c=kmeans_labels_low,cmap='Spectral')
xLabel = ax.set_xlabel('X')
yLabel = ax.set_ylabel('Y')
zLabel = ax.set_zlabel('Z')
- Applying PCA and visualizing the clusters on Medum Retention Data
In [196]:
pca = PCA(n_components=3).fit_transform(medium)
fig = plt.figure(figsize=(12, 7), dpi=80, facecolor='w', edgecolor='k')
ax = plt.axes(projection="3d")
ax.scatter3D(pca.T[0],pca.T[1],pca.T[2],c=kmeans_labels_medium,cmap='Spectral')
xLabel = ax.set_xlabel('X')
yLabel = ax.set_ylabel('Y')
zLabel = ax.set_zlabel('Z')
In [204]:
high['Clusters']=list(kmeans_labels_high)
(pd.DataFrame(high['Clusters'].value_counts()).rename(columns={'Clusters':'Number of Customers'})).T
Out[204]:
- More Number Of Customers in Cluster1
In [205]:
low['Clusters']=list(kmeans_labels_low)
(pd.DataFrame(low['Clusters'].value_counts()).rename(columns={'Clusters':'Number of Customers'})).T
Out[205]:
- More Number Of Customers in Cluster_0
In [206]:
medium['Clusters']=list(kmeans_labels_medium)
(pd.DataFrame(medium['Clusters'].value_counts()).rename(columns={'Clusters':'Number of Customers'})).T
Out[206]:
- More Number Of Customers in Cluster_0
In [207]:
high.set_index('Clusters')
grouped_num_high=high.groupby(by='Clusters').mean().round(1)
grouped_num_high = grouped_num.loc[:,['EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes', 'totalOrders',
'OrderFrequency', 'numberOfDaysWithBusiness', 'makingBusiness',
'ordergap']]
grouped_num_high
Out[207]:
- Aggregating numerical columns with mean by cluster id as index
In [208]:
low.set_index('Clusters')
grouped_num_low=low.groupby(by='Clusters').mean().round(1)
grouped_num_low = grouped_num.loc[:,['EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes', 'totalOrders',
'OrderFrequency', 'numberOfDaysWithBusiness', 'makingBusiness',
'ordergap']]
medium.set_index('Clusters')
grouped_num_medium=medium.groupby(by='Clusters').mean().round(1)
grouped_num_medium = grouped_num.loc[:,['EmailType_CustomizedEmail', 'MailOpened_no',
'MailOpened_yes', 'MailClicked_no', 'MailClicked_yes', 'totalOrders',
'OrderFrequency', 'numberOfDaysWithBusiness', 'makingBusiness',
'ordergap']]
- Dummifying the the categorical columns inorder to get the frequency of each column and cluster group set as a index
In [209]:
cluster_data_high = pd.get_dummies(data=high_exp, columns=['City', 'OnlineCommunication','PreferredDeliveryDay'])
cluster_data_low = pd.get_dummies(data=low_exp, columns=['City', 'OnlineCommunication','PreferredDeliveryDay'])
cluster_data_medium = pd.get_dummies(data=medium_exp, columns=['City', 'OnlineCommunication','PreferredDeliveryDay'])
In [210]:
cluster_data_high['Clusters'] = high['Clusters']
cluster_data_low['Clusters'] = low['Clusters']
cluster_data_medium['Clusters'] = medium['Clusters']
- Aggregating Categorical columns with frequency by cluster id as index
In [212]:
cluster_data_high.set_index('Clusters')
grouped_cat_high = cluster_data_high.groupby('Clusters').agg(
City_CITY1 = ('City_CITY1',np.count_nonzero ),
City_CITY2 = ('City_CITY2',np.count_nonzero ),
City_CITY3 = ('City_CITY3',np.count_nonzero ),
City_CITY4 = ('City_CITY4',np.count_nonzero ),
OnlineCommunication_0 = ('OnlineCommunication_0',np.count_nonzero ),
OnlineCommunication_1 = ('OnlineCommunication_1',np.count_nonzero ),
PreferredDeliveryDay_Friday = ('PreferredDeliveryDay_Friday',np.count_nonzero ),
PreferredDeliveryDay_Monday = ('PreferredDeliveryDay_Monday',np.count_nonzero ),
PreferredDeliveryDay_Saturday = ('PreferredDeliveryDay_Saturday',np.count_nonzero ),
PreferredDeliveryDay_Sunday = ('PreferredDeliveryDay_Sunday',np.count_nonzero ),
PreferredDeliveryDay_Thursday = ('PreferredDeliveryDay_Thursday',np.count_nonzero ),
PreferredDeliveryDay_Tuesday = ('PreferredDeliveryDay_Tuesday',np.count_nonzero ),
PreferredDeliveryDay_Wednesday = ('PreferredDeliveryDay_Wednesday',np.count_nonzero ),
)
cluster_data_low.set_index('Clusters')
grouped_cat_low = cluster_data_low.groupby('Clusters').agg(
City_CITY1 = ('City_CITY1',np.count_nonzero ),
City_CITY2 = ('City_CITY2',np.count_nonzero ),
City_CITY3 = ('City_CITY3',np.count_nonzero ),
City_CITY4 = ('City_CITY4',np.count_nonzero ),
OnlineCommunication_0 = ('OnlineCommunication_0',np.count_nonzero ),
OnlineCommunication_1 = ('OnlineCommunication_1',np.count_nonzero ),
PreferredDeliveryDay_Friday = ('PreferredDeliveryDay_Friday',np.count_nonzero ),
PreferredDeliveryDay_Monday = ('PreferredDeliveryDay_Monday',np.count_nonzero ),
PreferredDeliveryDay_Saturday = ('PreferredDeliveryDay_Saturday',np.count_nonzero ),
PreferredDeliveryDay_Sunday = ('PreferredDeliveryDay_Sunday',np.count_nonzero ),
PreferredDeliveryDay_Thursday = ('PreferredDeliveryDay_Thursday',np.count_nonzero ),
PreferredDeliveryDay_Tuesday = ('PreferredDeliveryDay_Tuesday',np.count_nonzero ),
PreferredDeliveryDay_Wednesday = ('PreferredDeliveryDay_Wednesday',np.count_nonzero ),
)
cluster_data_medium.set_index('Clusters')
grouped_cat_medium = cluster_data_medium.groupby('Clusters').agg(
City_CITY1 = ('City_CITY1',np.count_nonzero ),
City_CITY2 = ('City_CITY2',np.count_nonzero ),
City_CITY3 = ('City_CITY3',np.count_nonzero ),
City_CITY4 = ('City_CITY4',np.count_nonzero ),
OnlineCommunication_0 = ('OnlineCommunication_0',np.count_nonzero ),
OnlineCommunication_1 = ('OnlineCommunication_1',np.count_nonzero ),
PreferredDeliveryDay_Friday = ('PreferredDeliveryDay_Friday',np.count_nonzero ),
PreferredDeliveryDay_Monday = ('PreferredDeliveryDay_Monday',np.count_nonzero ),
PreferredDeliveryDay_Saturday = ('PreferredDeliveryDay_Saturday',np.count_nonzero ),
PreferredDeliveryDay_Sunday = ('PreferredDeliveryDay_Sunday',np.count_nonzero ),
PreferredDeliveryDay_Thursday = ('PreferredDeliveryDay_Thursday',np.count_nonzero ),
PreferredDeliveryDay_Tuesday = ('PreferredDeliveryDay_Tuesday',np.count_nonzero ),
PreferredDeliveryDay_Wednesday = ('PreferredDeliveryDay_Wednesday',np.count_nonzero ),
)
In [213]:
final_cluster_high = grouped_num_high.merge(grouped_cat_high,how='inner',on='Clusters')
final_cluster_low = grouped_num_low.merge(grouped_cat_low,how='inner',on='Clusters')
final_cluster_medium = grouped_num_medium.merge(grouped_cat_medium,how='inner',on='Clusters')
In [216]:
features_high = final_cluster_high.columns
features_low = final_cluster_low.columns
features_medium = final_cluster_medium.columns
Cluster Analysis On High RetentionPotential Data with Each column
In [225]:
plt.figure(figsize=(10,30))
for i,j in enumerate(features_high):
plt.subplot(12,2,i+1)
sns.barplot(final_cluster_high.index,final_cluster_high[j])
plt.title(j,fontdict={'color':'darkblue'})
plt.tight_layout()
plt.show()
Summary of the all graphs by using the cluster's for feature High
- In the Cluster 1 has high mean of email in Customized emails and the cluster 0 and 2 less compare to the cluster1
- In the variable No Malied Open feature the number of the mailed open does not open in the cluster 1 only has we compared to he cluster 0 And the cluster 2 has least number of malied opened.
- The number of mails seen in by the custmer, most number of the seen mails belongs to the cluster1 and cluster almost same, and the cluster 0 has least by seening the mails seen custmers.
- The number of the custmers belongs to the culsters, by the variable of no custmer Clicked mails, belongs to the cluster 1 and 0, cluster 1 has more compared to cluster 0 and clsuter 2 has least custmers.
- The number of custmer's Clicked mails, The custmer whole are Clicked the mails more has cluster o and cluster 1 has same number of custmer's. Where has there no number of custmer's belongs to the cluster 2.
- The total Orders variable the more number of custmer's belongs to the clsuter 2, where has the cluster 0 and 1 slightly equal number of custmers, The custmer's belongs to the cluster 0 and 1 less to cluster 2 custmer's.
- For the number of custmer's OrderFrequenc are, The custmer's order the more belongs to the cluster 2. And the Cluster 0 and 1 are equal number of custmer's ordered.
- In number of day business happend, the clsuter 1 has the more business happend, and the clsuter 0 has less number of business occured while compared to cluster 1, and the cluster 2 has least number of cluster's occured in the number of day business occured.
- In the making business, the number of custmer's almost same in each cluster 0, cluster1, and cluster2.
- The number of order gap between the custmer's, the number of custmers occured in the cluster 2, and the cluster 1 has less and cluster 0 has least number of custmer's order gap there.
- In city1 Custmer's occured more the clsuter 1 and were as cluster 0 as 20 custmers are occured, while in the cluster 2 has no custmer's are paticpated.
- In the city2 has more number of the custmer's belongs to cluster 2, while in the cluster 1 has 400 custmer's and in the cluster 0 has the 200 number of custmer's occured.
- In city3 it is same to the city1 while the figure number of custmer's are raise, while coming to the figures in the city3 cluster 1 has more 600 custmer's and in the cluster 0 has nealy 200 custmer's are there, were as no custmer's are there in the clsuter 2.
- In city4 the more number no custmer are belongs to the cluster 1 nearly 800 custmers, Where as cluster 2 and cluster 0 has less number of custmer's are there.
- In the online communication, the number of custmer's not communicate has belongs to cluster 2 are more, while the cluster 1 and 0.
- In the online communication, the number of custmer's are communicate belongs to cluster 1, in the cluster o has nearly 300 custmers and in the cluster 2 has least number of customer nearly 50.
- Deliveries on the Firday, more number of custmer's belongs to the cluster 1, and in the cluster 2 has more than cluster 0 number of custmer's are there.
- Delivers on the monday has similar number of custmer's are belongs to cluster are same to Friday's clusters custmer's.
- Delivers on the saturday, the more number of custmer's are belongs to the cluster 1 and cluster 0 has less while in the clsuter 2 has no custmer's.
- Delivers on the sunday has similar number of custmer's are belongs to cluster are same to saturday's clusters custmer's.
- Delivers on the thursday has more number of custmer's are belongs to clsuter 1 and cluster 2 and 0 are less compare to the cluster 1.
- Delivers on the tuesday has similar to the thursday's cluster custmers.
- Delivers on the wednesday also has same number of cluster and same number of custmer's are equal.
Cluster Analysis On Low RetentionPotential Data with Each column
In [228]:
plt.figure(figsize=(10,30))
for i,j in enumerate(features_low):
plt.subplot(12,2,i+1)
sns.barplot(final_cluster_low.index,final_cluster_low[j])
plt.title(j,fontdict={'color':'darkblue'})
plt.tight_layout()
plt.show()
We can summarize the all the graphs by the using the cluster's for feature Low.
Cluster 0: The more number of custmer's are occured in this cluster, the variables are City 1, City 2, city3, City4, Online Communication no, Online Communication yes, Deliveries on the Friday, Monday, Saturday, Sunday, Thurday, tuesday and wednesy these custmer's are occured in the cluster 0.
Cluster 1: The number of custmer's are occured in this cluster, the variables are Customized emails, No Mail opened, Yes Mail opened, No Mail clicked, Yes Mali Clicked, in these variables the cluster 1 has more number of custmer's occured.While in the other varibles like Total order, Order frequency, Number of Business days, Making Business and Ordergap are some custmer's are occured. In the reaming features no custmers are ocuured;
Cluster 2: In this cluster number of custmer are occured, in the variables Total order, Order frequency, Making Business and Order gap these feature are more number of custmers are occured. While in the other features some less in the feature are Eamil type customized type, No Mail Open, Yes Mail Open, No Mail Clicked and Number of Day's with Business. While in the other feature there is no single custmer's are not occured.
This is the conlusion of the features low.
Cluster Analysis On Medium RetentionPotential Data with Each column
In [229]:
plt.figure(figsize=(10,30))
for i,j in enumerate(features_medium):
plt.subplot(12,2,i+1)
sns.barplot(final_cluster_medium.index,final_cluster_medium[j])
plt.title(j,fontdict={'color':'darkblue'})
plt.tight_layout()
plt.show()
Summary of the all graphs by using the cluster's for feature Medium
Cluster 0: In this cluster all the features custmers are occurred in almost all the features medium, In the all the features the number of custmers are domination in all features.
Cluster 1: In this clsuter only feww features are occured in this cluster they are Email Type Customized, No Mailed Open, Yes Mailed Open,No Mail Clicked, Yes Mail Clicked, Total Orders, Order Frequency, Number of Days with business, making business, ordergap. These feature medium are more number of custmer are ocuured.
Cluster 2: In this cluster only few custmers are occured in the features are, Total orders, Order Frequency, Making Business, Order gap. While in the other features least number of custmer are occured in the participated.
This is the conlusion of fetures medium.
CONCLUSION
- By and large in our customers circle classification, customers do fall under the bracket(categorization) – LOW, MEDIUM, HIGH Retention Potentiality in any sort of industries.
- In order meet the profitability expectations without facing the condition of attrition,
Have to ensure that we have to centralize(concentrate) more on our medium retention potentiality customers in which our vigorous efforts have to lead them the way to high potentiality category consequentially (as a result).
For customers who shows us high potentiality, we have to make them satisfactory by laying out their needs without any complacency as usually.
- Here another focus has to be on the people who tends to have low retention potentiality by improving the approaching analysis with captivating & fascinating attempts from our end to pull customers towards purchasing/using services with our company.
Attributes to work on:
- Entice(attract) new customers using social media & social media giveaways during peak time, Improvisation of website’s search engine optimization, Marketing- frequent engaging with loyal customers, People in India are not richest majorly and category may drop under middle class – can say that we have collaborated with local business partners with minimal prices in which we are encouraging our local brands, Recontact old customers, Analyse through Geographic locality(classy, ethnic- what are they up-to ), collaborating credit card to give them offers(discounts) , Online advertising, Promotional activities in WhatsApp, Facebook, Instagram; Can make suggestions using recommendation engine algorithms( if you buy this, you may also like this bottom to the item they purchase), Robust exchange offers etc.
- These are few lists of ideas in which we may evolve and develop in business perspective.
In [ ]: